home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / value.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  7.6 KB  |  240 lines
  1. /* Definitions for values of C expressions, for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. /*
  22.  * The structure which defines the type of a value.  It should never
  23.  * be possible for a program lval value to survive over a call to the inferior
  24.  * (ie to be put into the history list or an internal variable).
  25.  */
  26. enum lval_type {
  27.   /* Not an lval.  */
  28.   not_lval,
  29.   /* In memory.  Could be a saved register.  */
  30.   lval_memory,
  31.   /* In a register.  */
  32.   lval_register,
  33.   /* In a gdb internal variable.  */
  34.   lval_internalvar,
  35.   /* Part of a gdb internal variable (structure field).  */
  36.   lval_internalvar_component
  37. #if 0
  38.   ,
  39.   /* In a register series in a frame not the current one, which may have been
  40.      partially saved or saved in different places (otherwise would be
  41.      lval_register or lval_memory).  */
  42.   lval_reg_frame_relative,
  43. #endif
  44. };
  45.  
  46. struct value
  47.   {
  48.     /* Type of value; either not an lval, or one of the various
  49.        different possible kinds of lval.  */
  50.     enum lval_type lval;
  51.     /* Location of value (if lval).  */
  52.     union
  53.       {
  54.     /* Address in inferior or byte of registers structure.  */
  55.     CORE_ADDR address;
  56.     /* Pointer to interrnal variable.  */
  57.     struct internalvar *internalvar;
  58. #if 0
  59.     /* Number of register.  Only used with
  60.        lval_reg_frame_relative.  */
  61.     int regnum;
  62. #endif
  63.       } location;
  64.     /* Describes offset of a value within lval a structure in bytes.  */
  65.     int offset;
  66.     /* Only used for bitfields; number of bits contained in them.  */
  67.     int bitsize;
  68.     /* Only used for bitfields; position of start of field.  */
  69.     int bitpos;
  70. #if 0
  71.     /* Frame value is relative to.  In practice, this address is only
  72.        used if the value is stored in several registers in other than
  73.        the current frame, and these registers have not all been saved
  74.        at the same place in memory.  This will be described in the
  75.        lval enum above as "lval_reg_frame_relative".  */
  76.     CORE_ADDR frame_addr;
  77. #endif
  78.     /* Type of the value.  */
  79.     struct type *type;
  80.     /* Values are stored in a chain, so that they can be deleted
  81.        easily over calls to the inferior.  Values assigned to internal
  82.        variables or put into the value history are taken off this
  83.        list.  */
  84.     struct value *next;
  85.     /* If an lval is forced to repeat, a new value is created with
  86.        these fields set.  The new value is not an lval.  */
  87.     short repeated;
  88.     short repetitions;
  89.     /* Register number if the value is from a register.  Is not kept
  90.        if you take a field of a structure that is stored in a
  91.        register.  Shouldn't it be?  */
  92.     short regno;
  93. #if 0
  94.     /* If zero, contents of this value are in the contents field.
  95.        If nonzero, contents are in inferior memory at address
  96.        in the location.address field plus the offset field
  97.        (and the lval field should be lval_memory).  */
  98.     char lazy;
  99.     /* If nonzero, this is the value of a variable which does not
  100.        actually exist in the program.  */
  101.     char optimized_out;
  102.     /* Actual contents of the value.  For use of this value; setting
  103.        it uses the stuff above.  Not valid if lazy is nonzero.
  104.        Target byte-order.  We force it to be aligned properly for any
  105.        possible value.  */
  106.     union {
  107.       long contents[1];
  108.       double force_double_align;
  109. #ifdef LONG_LONG
  110.       long long force_longlong_align;
  111. #endif
  112.     } aligner;
  113. #endif
  114.     long contents[1]; /* on the atari this will suffice for !_M68881 */
  115.         /* we take a hit on the 020 and up what the heck */
  116.   };
  117.  
  118. typedef struct value *value;
  119.  
  120. #define VALUE_TYPE(val) (val)->type
  121. #define VALUE_CONTENTS(val) ((char *) (val)->contents)
  122. /* for now */
  123. #define VALUE_CONTENTS_RAW(val) ((char *) (val)->contents)
  124. #define VALUE_LVAL(val) (val)->lval
  125. #define VALUE_ADDRESS(val) (val)->location.address
  126. #define VALUE_INTERNALVAR(val) (val)->location.internalvar
  127. #define VALUE_OFFSET(val) (val)->offset
  128. #define VALUE_BITSIZE(val) (val)->bitsize
  129. #define VALUE_BITPOS(val) (val)->bitpos
  130. #define VALUE_NEXT(val) (val)->next
  131. #define VALUE_REPEATED(val) (val)->repeated
  132. #define VALUE_REPETITIONS(val) (val)->repetitions
  133. #define VALUE_REGNO(val) (val)->regno
  134.  
  135. /* Convert a REF to the object referenced. */
  136.  
  137. #if 0
  138. #define COERCE_REF(arg)    \
  139. { if (TYPE_CODE ( VALUE_TYPE (arg)) == TYPE_CODE_REF)            \
  140.     arg = value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg)),        \
  141.              unpack_long (VALUE_TYPE (arg),            \
  142.                       VALUE_CONTENTS (arg)));}
  143. #else
  144. #define COERCE_REF(arg) /* nothing for now */
  145. #endif
  146.  
  147. /* If ARG is an array, convert it to a pointer.
  148.    If ARG is an enum, convert it to an integer.
  149.    If ARG is a function, convert it to a function pointer.
  150.  
  151.    References are dereferenced.  */
  152.  
  153. #define COERCE_ARRAY(arg)    \
  154. { COERCE_REF(arg);                            \
  155.   if (VALUE_REPEATED (arg)                        \
  156.       || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)        \
  157.     arg = value_coerce_array (arg);                    \
  158.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FUNC)                   \
  159.     arg = value_coerce_function (arg);                                  \
  160.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)            \
  161.     arg = value_cast (builtin_type_unsigned_int, arg);            \
  162. }
  163.  
  164. /* If ARG is an enum, convert it to an integer.  */
  165.  
  166. #if 0
  167. #define COERCE_ENUM(arg)    \
  168. { \
  169.  if (TYPE_CODE ( VALUE_TYPE (arg)) == TYPE_CODE_REF)            \
  170.     arg = value_ind (arg);                        \
  171.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)            \
  172.     arg = value_cast (builtin_type_unsigned_int, arg);            \
  173. }
  174. #else
  175. #define COERCE_ENUM(arg)    \
  176. { \
  177.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)            \
  178.     arg = value_cast (builtin_type_unsigned_int, arg);            \
  179. }
  180. #endif
  181.  
  182. /* Internal variables (variables for convenience of use of debugger)
  183.    are recorded as a chain of these structures.  */
  184.  
  185. struct internalvar
  186. {
  187.   struct internalvar *next;
  188.   char *name;
  189.   value value;
  190. };
  191.  
  192. long value_as_long ();
  193. double value_as_double ();
  194. long unpack_long ();
  195. double unpack_double ();
  196. long unpack_field_as_long ();
  197. value value_from_long ();
  198. value value_from_double ();
  199. value value_at ();
  200. value value_of_variable ();
  201. value value_of_register ();
  202. value read_var_value ();
  203. value locate_var_value ();
  204. value allocate_value ();
  205. value allocate_repeat_value ();
  206. value value_string ();
  207.  
  208. value value_binop ();
  209. value value_add ();
  210. value value_sub ();
  211. value value_coerce_array ();
  212. value value_coerce_function ();
  213. value value_ind ();
  214. value value_addr ();
  215. value value_assign ();
  216. value value_neg ();
  217. value value_lognot ();
  218. value value_struct_elt ();
  219. value value_field ();
  220. value value_cast ();
  221. value value_zero ();
  222. value value_repeat ();
  223. value value_subscript ();
  224.  
  225. value call_function ();
  226. value value_being_returned ();
  227.  
  228. value evaluate_expression ();
  229. value evaluate_type ();
  230. value parse_and_eval ();
  231. value parse_to_comma_and_eval ();
  232.  
  233. value access_value_history ();
  234. value value_of_internalvar ();
  235. struct internalvar *lookup_internalvar ();
  236.  
  237. int value_equal ();
  238. int value_less ();
  239. int value_zerop ();
  240.